/**
 * 泛型的上界
 * 写一个泛型类，类中有一个方法，求一个数组当中的最大值
 */
// 泛型的上界 -》T类型一定是实现了这个接口的。接口也指定为T类型 -》去比较T类型的数据

/**
 * public class MyArray<E extends Number> {
 * ...
 * }
 * E一定是Number的子类或者Number本身
 * 不拦着就擦除成Object,拦着就会擦到边界
 */
class TestDemo2<E extends Number>{

}
class Test5{
    public static void main(String[] args) {
        TestDemo2<Integer> testDemo2 = new TestDemo2<>();
        TestDemo2<Double> testDemo21 = new TestDemo2<>();
    }
}
/**
 *包装类和String类都是实现了Comparable<T>接口的
 */
//这个泛型的上界是个Comparable接口，上界是接口时，T必须是实现了这个接口(Comparable)的.
    //刚好对传入的类型变量做了约束，只能传实现了Comparable接口的，其余的不能传
class Alg<T extends Comparable<T>>{//这段代码的意思是：T一定实现了Comparable接口
    public T fingMax(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }

}
class Person implements Comparable<Person>{
    public int age;

    public Person(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = {1,2,3,4};
        Integer a = alg.fingMax(array);
        System.out.println(a);
        Alg<Person> alg2 = new Alg<>();
        Person[] person ={new Person(10),new Person(20)};
        Person p = alg2.fingMax(person);
        System.out.println(p);

    }
}
